home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / ddrible.c < prev    next >
C/C++ Source or Header  |  2000-04-10  |  8KB  |  261 lines
  1. /***************************************************************************
  2.  
  3.   vidhrdw.c
  4.  
  5.   Functions to emulate the video hardware of the machine.
  6.  
  7. ***************************************************************************/
  8.  
  9. #include "driver.h"
  10. #include "vidhrdw/generic.h"
  11.  
  12. extern int ddrible_int_enable_0;
  13. extern int ddrible_int_enable_1;
  14.  
  15. unsigned char *ddrible_fg_videoram;
  16. unsigned char *ddrible_bg_videoram;
  17. unsigned char *ddrible_spriteram_1;
  18. unsigned char *ddrible_spriteram_2;
  19.  
  20. static int ddribble_vregs[2][5];
  21.  
  22. static struct tilemap *fg_tilemap,*bg_tilemap;
  23.  
  24.  
  25. void ddrible_vh_convert_color_prom(unsigned char *palette, unsigned short *colortable,const unsigned char *color_prom)
  26. {
  27.     int i;
  28.     #define TOTAL_COLORS(gfxn) (Machine->gfx[gfxn]->total_colors * Machine->gfx[gfxn]->color_granularity)
  29.     #define COLOR(gfxn,offs) (colortable[Machine->drv->gfxdecodeinfo[gfxn].color_codes_start + offs])
  30.  
  31.  
  32.     /* build the lookup table for sprites. Palette is dynamic. */
  33.     for (i = 0;i < TOTAL_COLORS(3);i++)
  34.         COLOR(3,i) = (*(color_prom++) & 0x0f);
  35. }
  36.  
  37. WRITE_HANDLER( K005885_0_w )
  38. {
  39.     switch (offset){
  40.         case 0x03:    /* char bank selection for set 1 */
  41.             if ((data & 0x02) != ddribble_vregs[0][3]){
  42.                 ddribble_vregs[0][3] = (data & 0x02);
  43.                 tilemap_mark_all_tiles_dirty( fg_tilemap );
  44.             }
  45.             break;
  46.         case 0x04:    /* IRQ control, flipscreen */
  47.             ddrible_int_enable_0 = data & 0x02;
  48.             ddribble_vregs[0][4] = data;
  49.             break;
  50.         default:    /* 0x00: scrolly, 0x01-0x02: scrollx */
  51.             ddribble_vregs[0][offset] = data;
  52.     }
  53. }
  54.  
  55. WRITE_HANDLER( K005885_1_w )
  56. {
  57.     switch (offset){
  58.         case 0x03:    /* char bank selection for set 2 */
  59.             if (((data & 0x03) << 1) != ddribble_vregs[1][3]){
  60.                 ddribble_vregs[1][3] = (data & 0x03) << 1;
  61.                 tilemap_mark_all_tiles_dirty( bg_tilemap );
  62.             }
  63.             break;
  64.         case 0x04:    /* IRQ control, flipscreen */
  65.             ddrible_int_enable_1 = data & 0x02;
  66.             ddribble_vregs[1][4] = data;
  67.             break;
  68.         default:    /* 0x00: scrolly, 0x01-0x02: scrollx */
  69.             ddribble_vregs[1][offset] = data;
  70.     }
  71. }
  72.  
  73. /***************************************************************************
  74.  
  75.     Callbacks for the TileMap code
  76.  
  77. ***************************************************************************/
  78.  
  79. static UINT32 tilemap_scan(UINT32 col,UINT32 row,UINT32 num_cols,UINT32 num_rows)
  80. {
  81.     /* logical (col,row) -> memory offset */
  82.     return (col & 0x1f) + ((row & 0x1f) << 5) + ((col & 0x20) << 6);    /* skip 0x400 */
  83. }
  84.  
  85. static void get_fg_tile_info(int tile_index)
  86. {
  87.     unsigned char attr = ddrible_fg_videoram[tile_index];
  88.     int bank = ((attr & 0xc0) >> 6) + 4*(((attr & 0x20) >> 5) | ddribble_vregs[0][3]);
  89.     int num = ddrible_fg_videoram[tile_index + 0x400] + 256*bank;
  90.     SET_TILE_INFO(0,num,0);
  91.     tile_info.flags = TILE_FLIPYX((attr & 0x30) >> 4);
  92. }
  93.  
  94. static void get_bg_tile_info(int tile_index)
  95. {
  96.     unsigned char attr = ddrible_bg_videoram[tile_index];
  97.     int bank = ((attr & 0xc0) >> 6) + 4*(((attr & 0x20) >> 5) | ddribble_vregs[1][3]);
  98.     int num = ddrible_bg_videoram[tile_index + 0x400] + 256*bank;
  99.     SET_TILE_INFO(1,num,0);
  100.     tile_info.flags = TILE_FLIPYX((attr & 0x30) >> 4);
  101. }
  102.  
  103. /***************************************************************************
  104.  
  105.     Start the video hardware emulation.
  106.  
  107. ***************************************************************************/
  108.  
  109. int ddrible_vh_start ( void )
  110. {
  111.     fg_tilemap = tilemap_create(get_fg_tile_info,tilemap_scan,TILEMAP_TRANSPARENT,8,8,64,32);
  112.     bg_tilemap = tilemap_create(get_bg_tile_info,tilemap_scan,TILEMAP_OPAQUE,     8,8,64,32);
  113.  
  114.     if (!fg_tilemap || !bg_tilemap)
  115.         return 1;
  116.  
  117.     fg_tilemap->transparent_pen = 0;
  118.  
  119.     return 0;
  120. }
  121.  
  122. /***************************************************************************
  123.  
  124.     Memory handlers
  125.  
  126. ***************************************************************************/
  127.  
  128. WRITE_HANDLER( ddrible_fg_videoram_w )
  129. {
  130.     if (ddrible_fg_videoram[offset] != data)
  131.     {
  132.         ddrible_fg_videoram[offset] = data;
  133.         tilemap_mark_tile_dirty(fg_tilemap,offset & 0xbff);
  134.     }
  135. }
  136.  
  137. WRITE_HANDLER( ddrible_bg_videoram_w )
  138. {
  139.     if (ddrible_bg_videoram[offset] != data)
  140.     {
  141.         ddrible_bg_videoram[offset] = data;
  142.         tilemap_mark_tile_dirty(bg_tilemap,offset & 0xbff);
  143.     }
  144. }
  145.  
  146. /***************************************************************************
  147.  
  148.     Double Dribble sprites
  149.  
  150. Each sprite has 5 bytes:
  151. byte #0:    sprite number
  152. byte #1:
  153.     bits 0..2:    sprite bank #
  154.     bit 3:        not used?
  155.     bits 4..7:    sprite color
  156. byte #2:    y position
  157. byte #3:    x position
  158. byte #4:    attributes
  159.     bit 0:        x position (high bit)
  160.     bit 1:        ???
  161.     bits 2..4:    sprite size
  162.     bit 5:        flip x
  163.     bit 6:        flip y
  164.     bit 7:        unused?
  165.  
  166. ***************************************************************************/
  167.  
  168. static void ddribble_draw_sprites( struct osd_bitmap *bitmap, unsigned char* source, int lenght, int gfxset, int flipscreen )
  169. {
  170.     struct GfxElement *gfx = Machine->gfx[gfxset];
  171.     const unsigned char *finish = source + lenght;
  172.  
  173.     while( source < finish )
  174.     {
  175.         int number = source[0] | ((source[1] & 0x07) << 8);    /* sprite number */
  176.         int attr = source[4];                                /* attributes */
  177.         int sx = source[3] | ((attr & 0x01) << 8);            /* vertical position */
  178.         int sy = source[2];                                    /* horizontal position */
  179.         int flipx = attr & 0x20;                            /* flip x */
  180.         int flipy = attr & 0x40;                            /* flip y */
  181.         int color = (source[1] & 0xf0) >> 4;                /* color */
  182.         int width,height;
  183.  
  184.         if (flipscreen){
  185.                 flipx = !flipx;
  186.                 flipy = !flipy;
  187.                 sx = 240 - sx;
  188.                 sy = 240 - sy;
  189.  
  190.                 if ((attr & 0x1c) == 0x10){    /* ???. needed for some sprites in flipped mode */
  191.                     sx -= 0x10;
  192.                     sy -= 0x10;
  193.                 }
  194.         }
  195.  
  196.         switch (attr & 0x1c){
  197.             case 0x10:    /* 32x32 */
  198.                 width = height = 2; number &= (~3); break;
  199.             case 0x08:    /* 16x32 */
  200.                 width = 1; height = 2; number &= (~2); break;
  201.             case 0x04:    /* 32x16 */
  202.                 width = 2; height = 1; number &= (~1); break;
  203.             /* the hardware allow more sprite sizes, but ddribble doesn't use them */
  204.             default:    /* 16x16 */
  205.                 width = height = 1; break;
  206.         }
  207.  
  208.         {
  209.             static int x_offset[2] = { 0x00, 0x01 };
  210.             static int y_offset[2] = { 0x00, 0x02 };
  211.             int x,y, ex, ey;
  212.  
  213.             for( y=0; y < height; y++ ){
  214.                 for( x=0; x < width; x++ ){
  215.                     ex = flipx ? (width-1-x) : x;
  216.                     ey = flipy ? (height-1-y) : y;
  217.  
  218.                     drawgfx(bitmap,gfx,
  219.                         (number)+x_offset[ex]+y_offset[ey],
  220.                         color,
  221.                         flipx, flipy,
  222.                         sx+x*16,sy+y*16,
  223.                         &Machine->drv->visible_area,
  224.                         TRANSPARENCY_PEN, 0);
  225.                 }
  226.             }
  227.         }
  228.         source += 5;
  229.     }
  230. }
  231.  
  232. /***************************************************************************
  233.  
  234.     Display Refresh
  235.  
  236. ***************************************************************************/
  237.  
  238. void ddrible_vh_screenrefresh( struct osd_bitmap *bitmap, int full_refresh )
  239. {
  240.     tilemap_set_flip(fg_tilemap, (ddribble_vregs[0][4] & 0x08) ? (TILEMAP_FLIPY | TILEMAP_FLIPX) : 0);
  241.     tilemap_set_flip(bg_tilemap, (ddribble_vregs[1][4] & 0x08) ? (TILEMAP_FLIPY | TILEMAP_FLIPX) : 0);
  242.  
  243.     /* set scroll registers */
  244.     tilemap_set_scrollx(fg_tilemap,0,ddribble_vregs[0][1] | ((ddribble_vregs[0][2] & 0x01) << 8));
  245.     tilemap_set_scrollx(bg_tilemap,0,ddribble_vregs[1][1] | ((ddribble_vregs[1][2] & 0x01) << 8));
  246.     tilemap_set_scrolly(fg_tilemap,0,ddribble_vregs[0][0]);
  247.     tilemap_set_scrolly(bg_tilemap,0,ddribble_vregs[1][0]);
  248.  
  249.     tilemap_update( ALL_TILEMAPS );
  250.  
  251.     if (palette_recalc())
  252.         tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);
  253.  
  254.     tilemap_render( ALL_TILEMAPS );
  255.  
  256.     tilemap_draw(bitmap,bg_tilemap,0);
  257.     ddribble_draw_sprites(bitmap,ddrible_spriteram_1,0x07d,2,ddribble_vregs[0][4] & 0x08);
  258.     ddribble_draw_sprites(bitmap,ddrible_spriteram_2,0x140,3,ddribble_vregs[1][4] & 0x08);
  259.     tilemap_draw(bitmap,fg_tilemap,0);
  260. }
  261.